home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Dev / gcc263-src.lha / gcc-2.6.3 / cp / spew.c < prev    next >
C/C++ Source or Header  |  1994-10-12  |  12KB  |  439 lines
  1. /* Type Analyzer for GNU C++.
  2.    Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
  3.    Hacked... nay, bludgeoned... by Mark Eichin (eichin@cygnus.com)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. /* This file is the type analyzer for GNU C++.  To debug it, define SPEW_DEBUG
  23.    when compiling parse.c and spew.c.  */
  24.  
  25. #include "config.h"
  26. #include <stdio.h>
  27. #include "input.h"
  28. #include "tree.h"
  29. #include "lex.h"
  30. #include "parse.h"
  31. #include "cp-tree.h"
  32. #include "flags.h"
  33. #include "obstack.h"
  34.  
  35. /* This takes a token stream that hasn't decided much about types and
  36.    tries to figure out as much as it can, with excessive lookahead and
  37.    backtracking. */
  38.  
  39. /* fifo of tokens recognized and available to parser. */
  40. struct token  {
  41.   /* The values for YYCHAR will fit in a short.  */
  42.   short        yychar;
  43.   short        end_of_file;
  44.   YYSTYPE    yylval;
  45. };
  46.  
  47. static int do_aggr ();
  48.  
  49. /* From lex.c: */
  50. /* the declaration found for the last IDENTIFIER token read in.
  51.    yylex must look this up to detect typedefs, which get token type TYPENAME,
  52.    so it is left around in case the identifier is not a typedef but is
  53.    used in a context which makes it a reference to a variable.  */
  54. extern tree lastiddecl;        /* let our brains leak out here too */
  55. extern int    yychar;        /*  the lookahead symbol        */
  56. extern YYSTYPE    yylval;        /*  the semantic value of the        */
  57.                 /*  lookahead symbol            */
  58. extern int end_of_file;
  59.  
  60. struct obstack token_obstack;
  61. int first_token;
  62.   
  63. #ifdef SPEW_DEBUG
  64. int spew_debug = 0;
  65. static unsigned int yylex_ctr = 0;
  66. static int debug_yychar ();
  67. #endif
  68.  
  69. /* Initialize token_obstack. Called once, from init_lex.  */
  70. void
  71. init_spew ()
  72. {
  73.   gcc_obstack_init(&token_obstack);
  74. }
  75.  
  76. #ifdef SPEW_DEBUG
  77. /* Use functions for debugging...  */
  78.  
  79. /* Return the number of tokens available on the fifo. */
  80. static int
  81. num_tokens ()
  82. {
  83.   return (obstack_object_size(&token_obstack)/sizeof(struct token))
  84.     - first_token;
  85. }
  86.  
  87. /* Fetch the token N down the line from the head of the fifo. */
  88. static struct token*
  89. nth_token (n)
  90.      int n;
  91. {
  92.   /* could just have this do slurp_ implicitly, but this way is easier
  93.    * to debug... */
  94.   my_friendly_assert (n < num_tokens(), 298);
  95.   return ((struct token*)obstack_base(&token_obstack))+n+first_token;
  96. }
  97.  
  98. /* Add a token to the token fifo. */
  99. static void
  100. add_token (t)
  101.      struct token* t;
  102. {
  103.   obstack_grow(&token_obstack,t,sizeof (struct token));
  104. }
  105.  
  106. /* Consume the next token out of the fifo.  */
  107. static void
  108. consume_token()
  109. {
  110.   if (num_tokens() == 1)
  111.     {
  112.       obstack_free(&token_obstack, obstack_base (&token_obstack));
  113.       first_token = 0;
  114.     }
  115.   else
  116.     first_token++;
  117. }
  118.  
  119. #else
  120. /* ...otherwise use macros.  */
  121.  
  122. #define num_tokens() \
  123.   ((obstack_object_size(&token_obstack)/sizeof(struct token)) - first_token)
  124.  
  125. #define nth_token(N) \
  126.   (((struct token*)obstack_base(&token_obstack))+(N)+first_token)
  127.  
  128. #define add_token(T) obstack_grow(&token_obstack, (T), sizeof (struct token))
  129.  
  130. #define consume_token() \
  131.   (num_tokens() == 1                            \
  132.    ? (obstack_free (&token_obstack, obstack_base (&token_obstack)),    \
  133.       (first_token = 0))                        \
  134.    : first_token++)
  135. #endif
  136.  
  137. /* Pull in enough tokens from real_yylex that the queue is N long beyond
  138.    the current token.  */
  139.  
  140. static void
  141. scan_tokens (n)
  142.      int n;
  143. {
  144.   int i;
  145.   struct token *tmp;
  146.  
  147.   /* We cannot read past certain tokens, so make sure we don't.  */
  148.   i = num_tokens ();
  149.   if (i > n)
  150.     return;
  151.   while (i-- > 0)
  152.     {
  153.       tmp = nth_token (i);
  154.       /* Never read past these characters: they might separate
  155.      the current input stream from one we save away later.  */
  156.       if (tmp->yychar == '{' || tmp->yychar == ':' || tmp->yychar == ';')
  157.     goto pad_tokens;
  158.     }
  159.  
  160.   while (num_tokens() <= n)
  161.     {
  162.       obstack_blank(&token_obstack,sizeof (struct token));
  163.       tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
  164.       tmp->yychar = real_yylex();
  165.       tmp->end_of_file = end_of_file;
  166.       tmp->yylval = yylval;
  167.       end_of_file = 0;
  168.       if (tmp->yychar == '{'
  169.       || tmp->yychar == ':'
  170.       || tmp->yychar == ';')
  171.     {
  172.     pad_tokens:
  173.       while (num_tokens () <= n)
  174.         {
  175.           obstack_blank(&token_obstack,sizeof (struct token));
  176.           tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
  177.           tmp->yychar = EMPTY;
  178.           tmp->end_of_file = 0;
  179.         }
  180.     }
  181.     }
  182. }
  183.  
  184. /* Create room for N tokens at the front of the fifo.  This is used
  185.    to insert new tokens into the stream ahead of the current token.  */
  186.  
  187. static void
  188. shift_tokens (n)
  189.      int n;
  190. {
  191.   if (first_token >= n)
  192.     first_token -= n;
  193.   else
  194.     {
  195.       int old_token_count = num_tokens ();
  196.       char *tmp;
  197.  
  198.       obstack_blank (&token_obstack, (n-first_token) * sizeof (struct token));
  199.       if (old_token_count)
  200.     {
  201.       tmp = (char *)alloca ((num_tokens () + (n-first_token))
  202.                 * sizeof (struct token));
  203.       /* This move does not rely on the system being able to handle
  204.          overlapping moves.  */
  205.       bcopy ((char *) nth_token (0), tmp,
  206.          old_token_count * sizeof (struct token));
  207.       bcopy (tmp, (char *) nth_token (n),
  208.          old_token_count * sizeof (struct token));
  209.     }
  210.       first_token = 0;
  211.     }
  212. }
  213.  
  214. static int
  215. probe_obstack (h, obj, nlevels)
  216.      struct obstack *h;
  217.      tree obj;
  218.      unsigned int nlevels;
  219. {
  220.   register struct _obstack_chunk*  lp;    /* below addr of any objects in this chunk */
  221.   register struct _obstack_chunk*  plp;    /* point to previous chunk if any */
  222.  
  223.   lp = (h)->chunk;
  224.   /* We use >= rather than > since the object cannot be exactly at
  225.      the beginning of the chunk but might be an empty object exactly
  226.      at the end of an adjacent chunk. */
  227.   for (; nlevels != 0 && lp != 0 && ((tree)lp >= obj || (tree)lp->limit < obj);
  228.        nlevels -= 1)
  229.     {
  230.       plp = lp->prev;
  231.       lp = plp;      
  232.     }
  233.   return nlevels != 0 && lp != 0;
  234. }
  235.  
  236. /* from lex.c: */
  237. /* Value is 1 (or 2) if we should try to make the next identifier look like
  238.    a typename (when it may be a local variable or a class variable).
  239.    Value is 0 if we treat this name in a default fashion. */
  240. extern int looking_for_typename;
  241. int looking_for_template;
  242.  
  243. extern struct obstack *current_obstack, *saveable_obstack;
  244. tree got_scope;
  245.  
  246. int
  247. yylex()
  248. {
  249.   struct token tmp_token;
  250.   tree trrr;
  251.  
  252.  retry:
  253. #ifdef SPEW_DEBUG
  254.   if (spew_debug)
  255.   {
  256.     yylex_ctr ++;
  257.     fprintf(stderr, "\t\t## %d ##",yylex_ctr);
  258.   }
  259. #endif
  260.  
  261.   /* if we've got tokens, send them */
  262.   if (num_tokens())
  263.     {
  264.       tmp_token= *nth_token(0);
  265.  
  266.       /* TMP_TOKEN.YYLVAL.TTYPE may have been allocated on the wrong obstack.
  267.      If we don't find it in CURRENT_OBSTACK's current or immediately
  268.      previous chunk, assume it was and copy it to the current obstack.  */
  269.       if ((tmp_token.yychar == CONSTANT
  270.        || tmp_token.yychar == STRING)
  271.       && ! TREE_PERMANENT (tmp_token.yylval.ttype)
  272.       && ! probe_obstack (current_obstack, tmp_token.yylval.ttype, 2)
  273.       && ! probe_obstack (saveable_obstack, tmp_token.yylval.ttype, 2))
  274.     tmp_token.yylval.ttype = copy_node (tmp_token.yylval.ttype);
  275.     }
  276.   else
  277.     {
  278.       /* if not, grab the next one and think about it */
  279.       tmp_token.yychar = real_yylex ();
  280.       tmp_token.yylval = yylval;
  281.       tmp_token.end_of_file = end_of_file;
  282.       add_token(&tmp_token);
  283.     }
  284.  
  285.   /* many tokens just need to be returned. At first glance, all we
  286.    * have to do is send them back up, but some of them are needed to
  287.    * figure out local context. */
  288.   switch(tmp_token.yychar)
  289.     {
  290.     case EMPTY:
  291.       /* This is a lexical no-op.  */
  292.       consume_token ();
  293. #ifdef SPEW_DEBUG    
  294.       if (spew_debug)
  295.     debug_yychar (tmp_token.yychar);
  296. #endif
  297.       goto retry;
  298.  
  299.     case IDENTIFIER:
  300.       scan_tokens (1);
  301.       if (nth_token (1)->yychar == SCOPE)
  302.     /* Don't interfere with the setting from an 'aggr' prefix.  */
  303.     looking_for_typename++;
  304.       else if (nth_token (1)->yychar == '<')
  305.     looking_for_template = 1;
  306.  
  307.       trrr = lookup_name (tmp_token.yylval.ttype, -2);
  308.  
  309.       if (trrr)
  310.     {
  311.       tmp_token.yychar = identifier_type (trrr);
  312.       switch (tmp_token.yychar)
  313.         {
  314.         case TYPENAME:
  315.           lastiddecl = identifier_typedecl_value (tmp_token.yylval.ttype);
  316.           if (lastiddecl != trrr)
  317.         {
  318.           lastiddecl = trrr;
  319.           if (got_scope)
  320.             tmp_token.yylval.ttype = DECL_NESTED_TYPENAME (trrr);
  321.         }
  322.           break;
  323.         case IDENTIFIER:
  324.           lastiddecl = trrr;
  325.           break;
  326.         case PTYPENAME:
  327.           lastiddecl = NULL_TREE;
  328.           break;
  329.         default:
  330.           my_friendly_abort (101);
  331.         }
  332.     }
  333.       else
  334.     lastiddecl = trrr;
  335.       got_scope = NULL_TREE;
  336.       /* and fall through to... */
  337.     case TYPENAME:
  338.     case PTYPENAME:
  339.       consume_token ();
  340.       if (looking_for_typename > 0)
  341.     looking_for_typename--;
  342.       looking_for_template = 0;
  343.       break;
  344.  
  345.     case SCSPEC:
  346.       /* do_aggr needs to check if the previous token was RID_FRIEND,
  347.      so just increment first_token instead of calling consume_token. */
  348.       first_token++;
  349.       break;
  350.     case TYPESPEC:
  351.       consume_token ();
  352.       break;
  353.  
  354.     case AGGR:
  355.       *nth_token(0) = tmp_token;
  356.       do_aggr ();
  357.       /* fall through to output... */
  358.     case ENUM:
  359.       /* Set this again, in case we are rescanning.  */
  360.       looking_for_typename = 1;
  361.       /* fall through... */
  362.     default:
  363.       consume_token();
  364.     }
  365.  
  366.   yylval = tmp_token.yylval;
  367.   yychar = tmp_token.yychar;
  368.   end_of_file = tmp_token.end_of_file;
  369. #ifdef SPEW_DEBUG    
  370.   if (spew_debug)
  371.     debug_yychar(yychar);
  372. #endif
  373.   return yychar;
  374. }
  375.  
  376. /* token[0] == AGGR (struct/union/enum)
  377.  * Thus, token[1] is either a TYPENAME or a TYPENAME_DEFN.
  378.  * If token[2] == '{' or ':' then it's TYPENAME_DEFN.
  379.  * It's also a definition if it's a forward declaration (as in 'struct Foo;')
  380.  * which we can tell lf token[2] == ';' *and* token[-1] != FRIEND.
  381.  */
  382. static int
  383. do_aggr ()
  384. {
  385.   int yc1, yc2;
  386.   
  387.   scan_tokens (2);
  388.   yc1 = nth_token (1)->yychar;
  389.   if (yc1 != TYPENAME && yc1 != IDENTIFIER && yc1 != PTYPENAME)
  390.     return 0;
  391.   yc2 = nth_token (2)->yychar;
  392.   if (yc2 == ';')
  393.     {
  394.       /* It's a forward declaration iff we were not preceded by 'friend'. */
  395.       if (first_token > 0 && nth_token (-1)->yychar == SCSPEC
  396.       && nth_token (-1)->yylval.ttype == ridpointers[(int) RID_FRIEND])
  397.     return 0;
  398.     }
  399.   else if (yc2 != '{' && yc2 != ':')
  400.     return 0;
  401.  
  402.   switch (yc1)
  403.     {
  404.     case TYPENAME:
  405.       nth_token (1)->yychar = TYPENAME_DEFN;
  406.       break;
  407.     case PTYPENAME:
  408.       nth_token (1)->yychar = PTYPENAME_DEFN;
  409.       break;
  410.     case IDENTIFIER:
  411.       nth_token (1)->yychar = IDENTIFIER_DEFN;
  412.       break;
  413.     default:
  414.       my_friendly_abort (102);
  415.     }
  416.   return 0;
  417. }  
  418.   
  419. #ifdef SPEW_DEBUG    
  420. /* debug_yychar takes a yychar (token number) value and prints its name. */
  421. static int
  422. debug_yychar (yy)
  423.      int yy;
  424. {
  425.   /* In parse.y: */
  426.   extern char *debug_yytranslate ();
  427.   
  428.   int i;
  429.   
  430.   if(yy<256) {
  431.     fprintf (stderr, "<%d: %c >\n", yy, yy);
  432.     return 0;
  433.   }
  434.   fprintf (stderr, "<%d:%s>\n", yy, debug_yytranslate (yy));
  435.   return 1;
  436. }
  437.  
  438. #endif
  439.